@Test  
void dirtyReading() throws SQLException {  
    setUp(createH2DataSource());  
  
    // db에 새로운 연결(사용자A)을 받아와서  
    final var connection = dataSource.getConnection();  
  
    // 트랜잭션을 시작한다.  
    connection.setAutoCommit(false);  
  
    // db에 데이터를 추가하고 커밋하기 전에  
    userDao.insert(connection, new User("gugu", "password", "hkkang@woowahan.com"));  
  
    new Thread(RunnableWrapper.accept(() -> {  
        // db에 connection(사용자A)이 아닌 새로운 연결인 subConnection(사용자B)을 받아온다.  
        final var subConnection = dataSource.getConnection();  
  
        // 적절한 격리 레벨을 찾는다.  
        final int isolationLevel = Connection.TRANSACTION_READ_UNCOMMITTED;  
  
        // 트랜잭션 격리 레벨을 설정한다.  
        subConnection.setTransactionIsolation(isolationLevel);  
  
        // ❗️gugu 객체는 connection에서 아직 커밋하지 않은 상태다.  
        // 격리 레벨에 따라 커밋하지 않은 gugu 객체를 조회할 수 있다.  
        // 사용자B가 사용자A가 커밋하지 않은 데이터를 조회하는게 적절할까?  
        final var actual = userDao.findByAccount(subConnection, "gugu");  
  
        // 트랜잭션 격리 레벨에 따라 아래 테스트가 통과한다.  
        // 어떤 격리 레벨일 때 다른 연결의 커밋 전 데이터를 조회할 수 있을지 찾아보자.  
        // 다른 격리 레벨은 어떤 결과가 나오는지 직접 확인해보자.  
        log.info("isolation level : {}, user : {}", isolationLevel, actual);  
        assertThat(actual).isNull();  
    })).start();  
  
    sleep(0.5);  
  
    // 롤백하면 사용자A의 user 데이터를 저장하지 않았는데 사용자B는 user 데이터가 있다고 인지한 상황이 된다.  
    connection.rollback();  
}

final int isolationLevel = Connection.TRANSACTION_READ_UNCOMMITTED;  

@Test  
void noneRepeatable() throws SQLException {  
    setUp(createH2DataSource());  
  
    // 테스트 전에 필요한 데이터를 추가한다.  
    userDao.insert(dataSource.getConnection(), new User("gugu", "password", "hkkang@woowahan.com"));  
  
    // db에 새로운 연결(사용자A)을 받아와서  
    final var connection = dataSource.getConnection();  
  
    // 트랜잭션을 시작한다.  
    connection.setAutoCommit(false);  
  
    // 적절한 격리 레벨을 찾는다.  
    final int isolationLevel = Connection.TRANSACTION_READ_COMMITTED;  
  
    // 트랜잭션 격리 레벨을 설정한다.  
    connection.setTransactionIsolation(isolationLevel);  
  
    // 사용자A가 gugu 객체를 조회했다.  
    final var user = userDao.findByAccount(connection, "gugu");  
    log.info("user : {}", user);  
  
    new Thread(RunnableWrapper.accept(() -> {  
        // 사용자B가 새로 연결하여  
        final var subConnection = dataSource.getConnection();  
  
        // 사용자A가 조회한 gugu 객체를 사용자B가 다시 조회했다.  
        final var anotherUser = userDao.findByAccount(subConnection, "gugu");  
  
        // ❗사용자B가 gugu 객체의 비밀번호를 변경했다.(subConnection은 auto commit 상태)  
        anotherUser.changePassword("qqqq");  
        userDao.update(subConnection, anotherUser);  
    })).start();  
  
    sleep(0.5);  
  
    // 사용자A가 다시 gugu 객체를 조회했다.  
    // 사용자B는 패스워드를 변경하고 아직 커밋하지 않았다.  
    final var actual = userDao.findByAccount(connection, "gugu");  
  
    // 트랜잭션 격리 레벨에 따라 아래 테스트가 통과한다.  
    // 각 격리 레벨은 어떤 결과가 나오는지 직접 확인해보자.  
    log.info("isolation level : {}, user : {}", isolationLevel, actual);  
    assertThat(actual.getPassword()).isEqualTo("password");  
  
    connection.rollback();  
}

@Test  
void phantomReading() throws SQLException {  
  
    // testcontainer로 docker를 실행해서 mysql에 연결한다.  
    final var mysql = new MySQLContainer<>(DockerImageName.parse("mysql:8.0.30"))  
            .withLogConsumer(new Slf4jLogConsumer(log));  
    mysql.withUrlParam("allowMultiQueries", "true");  
    mysql.start();  
    setUp(createMySQLDataSource(mysql));  
  
    // 테스트 전에 필요한 데이터를 추가한다.  
    userDao.insert(dataSource.getConnection(), new User("gugu", "password", "hkkang@woowahan.com"));  
  
    // db에 새로운 연결(사용자A)을 받아와서  
    final var connection = dataSource.getConnection();  
  
    // 트랜잭션을 시작한다.  
    connection.setAutoCommit(false);  
  
    // 적절한 격리 레벨을 찾는다.  
    final int isolationLevel = Connection.TRANSACTION_REPEATABLE_READ;  
  
    // 트랜잭션 격리 레벨을 설정한다.  
    connection.setTransactionIsolation(isolationLevel);  
  
    // 사용자A가 id로 범위를 조회했다.  
    userDao.findGreaterThan(connection, 1);  
  
    new Thread(RunnableWrapper.accept(() -> {  
        // 사용자B가 새로 연결하여  
        final var subConnection = dataSource.getConnection();  
  
        // 트랜잭션 시작  
        subConnection.setAutoCommit(false);  
  
        // 새로운 user 객체를 저장했다.  
        // id는 2로 저장된다.  
        userDao.insert(subConnection, new User("bird", "password", "bird@woowahan.com"));  
  
        subConnection.commit();  
    })).start();  
  
    sleep(0.5);  
  
    // MySQL에서 팬텀 읽기를 시연하려면 update를 실행해야 한다.  
    // http://stackoverflow.com/questions/42794425/unable-to-produce-a-phantom-read/42796969#42796969    userDao.updatePasswordGreaterThan(connection, "qqqq", 1);  
  
    // 사용자A가 다시 id로 범위를 조회했다.  
    final var actual = userDao.findGreaterThan(connection, 1);  
  
    // 트랜잭션 격리 레벨에 따라 아래 테스트가 통과한다.  
    // 각 격리 레벨은 어떤 결과가 나오는지 직접 확인해보자.  
    log.info("isolation level : {}, user : {}", isolationLevel, actual);  
    assertThat(actual).hasSize(1);  
  
    connection.rollback();  
    mysql.close();  
}

@Test  
void testRequired() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithRequired();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

private void logActualTransactionActive() {  
    final var currentTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    final var actualTransactionActive = TransactionSynchronizationManager.isActualTransactionActive();  
    final var emoji = actualTransactionActive ? "✅" : "❌";  
    log.info("\n{} is Actual Transaction Active : {} {}", currentTransactionName, emoji, actualTransactionActive);  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithRequired() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithRequired();  
  
    return of(firstTransactionName, secondTransactionName);  
}

private Set<String> of(final String firstTransactionName, final String secondTransactionName) {  
    return Stream.of(firstTransactionName, secondTransactionName)  
            .filter(transactionName -> !Objects.isNull(transactionName))  
            .collect(Collectors.toSet());  
}

// SecondUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public String saveSecondTransactionWithRequired() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testRequiredNew() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithRequiredNew();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// First UserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithRequiredNew() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithRequiresNew();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// Second UserService.java
@Transactional(propagation = Propagation.REQUIRES_NEW)  
public String saveSecondTransactionWithRequiresNew() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testRequiredNewWithRollback() {  
    assertThat(firstUserService.findAll()).hasSize(0);  
  
    assertThatThrownBy(() -> firstUserService.saveAndExceptionWithRequiredNew())  
            .isInstanceOf(RuntimeException.class);  
  
    assertThat(firstUserService.findAll()).hasSize(-1);  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveAndExceptionWithRequiredNew() {  
    secondUserService.saveSecondTransactionWithRequiresNew();  
  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    throw new RuntimeException();  
}

// Second UserService.java
@Transactional(propagation = Propagation.REQUIRES_NEW)  
public String saveSecondTransactionWithRequiresNew() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testSupports() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithSupports();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithSupports() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithSupports();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// SecondUserService.java
@Transactional(propagation = Propagation.SUPPORTS)  
public String saveSecondTransactionWithSupports() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testMandatory() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithMandatory();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithMandatory() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithMandatory();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// SecondUserService.java
@Transactional(propagation = Propagation.MANDATORY)  
public String saveSecondTransactionWithMandatory() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testNotSupported() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithNotSupported();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithNotSupported() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithNotSupported();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// SecondUserService.java
@Transactional(propagation = Propagation.NOT_SUPPORTED)  
public String saveSecondTransactionWithNotSupported() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testNested() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithNested();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithNested() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithNested();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// SecondUserService.java
@Transactional(propagation = Propagation.NESTED)  
public String saveSecondTransactionWithNested() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}

@Test  
void testNever() {  
    final Set<String> actual = firstUserService.saveFirstTransactionWithNever();  
  
    log.info("transactions : {}", actual);  
    assertThat(actual)  
            .hasSize(0)  
            .containsExactly("");  
}

// FirstUserService.java
@Transactional(propagation = Propagation.REQUIRED)  
public Set<String> saveFirstTransactionWithNever() {  
    final var firstTransactionName = TransactionSynchronizationManager.getCurrentTransactionName();  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
  
    final var secondTransactionName = secondUserService.saveSecondTransactionWithNever();  
  
    return of(firstTransactionName, secondTransactionName);  
}

// SecondUserService.java
@Transactional(propagation = Propagation.NEVER)  
public String saveSecondTransactionWithNever() {  
    userRepository.save(User.createTest());  
    logActualTransactionActive();  
    return TransactionSynchronizationManager.getCurrentTransactionName();  
}